{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
      "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
      "\tThe instructions to do this will be given in a section of the notebook below.\n",
      "\tThere will be an option for Colab users and another for Jupyter (local) users.\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: forward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "it's sigmoid gate. In one dimention condition, for large value, the gate will be saturated, so the gradient will be zero.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Testing training loss (regularization = 1)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 7.98e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, f'Problem with training-time loss: {loss} correct: {correct_loss}'\n",
    "\n",
    "print('Testing training loss (regularization = 1)')\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, f'Problem with training-time loss: {loss} correct: {correct_loss}'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "tln_solver_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.829613\n",
      "(Iteration 201 / 4900) loss: 1.857390\n",
      "(Iteration 301 / 4900) loss: 1.744448\n",
      "(Iteration 401 / 4900) loss: 1.420187\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.565913\n",
      "(Iteration 601 / 4900) loss: 1.700510\n",
      "(Iteration 701 / 4900) loss: 1.732213\n",
      "(Iteration 801 / 4900) loss: 1.688361\n",
      "(Iteration 901 / 4900) loss: 1.439529\n",
      "(Epoch 2 / 10) train acc: 0.497000; val_acc: 0.468000\n",
      "(Iteration 1001 / 4900) loss: 1.385772\n",
      "(Iteration 1101 / 4900) loss: 1.278401\n",
      "(Iteration 1201 / 4900) loss: 1.641580\n",
      "(Iteration 1301 / 4900) loss: 1.438847\n",
      "(Iteration 1401 / 4900) loss: 1.172536\n",
      "(Epoch 3 / 10) train acc: 0.490000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.346286\n",
      "(Iteration 1601 / 4900) loss: 1.268492\n",
      "(Iteration 1701 / 4900) loss: 1.318215\n",
      "(Iteration 1801 / 4900) loss: 1.395750\n",
      "(Iteration 1901 / 4900) loss: 1.338233\n",
      "(Epoch 4 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 2001 / 4900) loss: 1.343165\n",
      "(Iteration 2101 / 4900) loss: 1.393173\n",
      "(Iteration 2201 / 4900) loss: 1.276734\n",
      "(Iteration 2301 / 4900) loss: 1.287951\n",
      "(Iteration 2401 / 4900) loss: 1.352778\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.475000\n",
      "(Iteration 2501 / 4900) loss: 1.390234\n",
      "(Iteration 2601 / 4900) loss: 1.276361\n",
      "(Iteration 2701 / 4900) loss: 1.111768\n",
      "(Iteration 2801 / 4900) loss: 1.271688\n",
      "(Iteration 2901 / 4900) loss: 1.272039\n",
      "(Epoch 6 / 10) train acc: 0.546000; val_acc: 0.509000\n",
      "(Iteration 3001 / 4900) loss: 1.304489\n",
      "(Iteration 3101 / 4900) loss: 1.346667\n",
      "(Iteration 3201 / 4900) loss: 1.325510\n",
      "(Iteration 3301 / 4900) loss: 1.392728\n",
      "(Iteration 3401 / 4900) loss: 1.402001\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 3501 / 4900) loss: 1.319024\n",
      "(Iteration 3601 / 4900) loss: 1.153287\n",
      "(Iteration 3701 / 4900) loss: 1.180922\n",
      "(Iteration 3801 / 4900) loss: 1.093164\n",
      "(Iteration 3901 / 4900) loss: 1.135902\n",
      "(Epoch 8 / 10) train acc: 0.568000; val_acc: 0.490000\n",
      "(Iteration 4001 / 4900) loss: 1.191735\n",
      "(Iteration 4101 / 4900) loss: 1.359396\n",
      "(Iteration 4201 / 4900) loss: 1.227283\n",
      "(Iteration 4301 / 4900) loss: 1.024113\n",
      "(Iteration 4401 / 4900) loss: 1.327583\n",
      "(Epoch 9 / 10) train acc: 0.592000; val_acc: 0.504000\n",
      "(Iteration 4501 / 4900) loss: 0.963330\n",
      "(Iteration 4601 / 4900) loss: 1.445619\n",
      "(Iteration 4701 / 4900) loss: 1.007542\n",
      "(Iteration 4801 / 4900) loss: 1.005175\n",
      "(Epoch 10 / 10) train acc: 0.611000; val_acc: 0.512000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                lr_decay=0.95,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3013067151359436\n",
      "W1 relative error: 6.61e-07\n",
      "W2 relative error: 7.09e-07\n",
      "W3 relative error: 1.87e-07\n",
      "b1 relative error: 1.74e-08\n",
      "b2 relative error: 3.21e-09\n",
      "b3 relative error: 1.22e-10\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.303923358473344\n",
      "W1 relative error: 1.52e-08\n",
      "W2 relative error: 2.15e-08\n",
      "W3 relative error: 1.83e-07\n",
      "b1 relative error: 2.20e-08\n",
      "b2 relative error: 3.85e-09\n",
      "b3 relative error: 8.38e-11\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "    print('Running check with reg = ', reg)\n",
    "    model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "    loss, grads = model.loss(X, y)\n",
    "    print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "    for name in sorted(grads):\n",
    "#         print(name,grads[name].shape)\n",
    "        f = lambda _: model.loss(X, y)[0]\n",
    "        grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "        print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 962.796913\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.113000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.136000\n",
      "(Epoch 2 / 20) train acc: 0.400000; val_acc: 0.109000\n",
      "(Epoch 3 / 20) train acc: 0.600000; val_acc: 0.125000\n",
      "(Epoch 4 / 20) train acc: 0.860000; val_acc: 0.117000\n",
      "(Epoch 5 / 20) train acc: 0.900000; val_acc: 0.121000\n",
      "(Iteration 11 / 40) loss: 22.967361\n",
      "(Epoch 6 / 20) train acc: 0.920000; val_acc: 0.116000\n",
      "(Epoch 7 / 20) train acc: 0.860000; val_acc: 0.109000\n",
      "(Epoch 8 / 20) train acc: 0.900000; val_acc: 0.108000\n",
      "(Epoch 9 / 20) train acc: 0.900000; val_acc: 0.112000\n",
      "(Epoch 10 / 20) train acc: 0.940000; val_acc: 0.116000\n",
      "(Iteration 21 / 40) loss: 1.252421\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.115000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Iteration 31 / 40) loss: 0.000000\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.119000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = np.sqrt(2/(100)) #* 1e-1  # Experiment with this!\n",
    "learning_rate = 1e-3  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 344.651598\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.110000\n",
      "(Epoch 1 / 20) train acc: 0.220000; val_acc: 0.101000\n",
      "(Epoch 2 / 20) train acc: 0.300000; val_acc: 0.110000\n",
      "(Epoch 3 / 20) train acc: 0.540000; val_acc: 0.097000\n",
      "(Epoch 4 / 20) train acc: 0.580000; val_acc: 0.111000\n",
      "(Epoch 5 / 20) train acc: 0.700000; val_acc: 0.120000\n",
      "(Iteration 11 / 40) loss: 38.483072\n",
      "(Epoch 6 / 20) train acc: 0.860000; val_acc: 0.107000\n",
      "(Epoch 7 / 20) train acc: 0.860000; val_acc: 0.112000\n",
      "(Epoch 8 / 20) train acc: 0.920000; val_acc: 0.114000\n",
      "(Epoch 9 / 20) train acc: 0.840000; val_acc: 0.109000\n",
      "(Epoch 10 / 20) train acc: 0.860000; val_acc: 0.103000\n",
      "(Iteration 21 / 40) loss: 3.516505\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.112000\n",
      "(Epoch 12 / 20) train acc: 0.960000; val_acc: 0.112000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Iteration 31 / 40) loss: 0.000011\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.108000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.108000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = np.sqrt(2/(100)) #* 1e-1  # Experiment with this!\n",
    "learning_rate = 1e-4  # Experiment with this!\n",
    "\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "The five layer net is more sensitive to the initialization scale.\n",
    "\n",
    "Accoeding to the paper, `np.sqrt(2/n)` should be good standard diviation, where n is the number(row) of the input data.\n",
    "\n",
    "Here `n` should be 100 for most layers(though for the start layer, n should be #data).\n",
    "\n",
    "Then different bias were tried to test the sensitivty: multiply 0.1 to each initialization scale, and we can find that for the 3-layers network, the final train acc is 0.84 while for the 5-layers network is 0.1.\n",
    "\n",
    "In conclusion, the deeper the network, the harder to achieve the best weight, and the more sensitive to the initialization scale.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.486560\n",
      "(Epoch 0 / 5) train acc: 0.105000; val_acc: 0.113000\n",
      "(Iteration 11 / 200) loss: 2.247741\n",
      "(Iteration 21 / 200) loss: 2.154521\n",
      "(Iteration 31 / 200) loss: 2.144891\n",
      "(Epoch 1 / 5) train acc: 0.267000; val_acc: 0.209000\n",
      "(Iteration 41 / 200) loss: 2.125381\n",
      "(Iteration 51 / 200) loss: 2.058228\n",
      "(Iteration 61 / 200) loss: 2.019895\n",
      "(Iteration 71 / 200) loss: 1.981505\n",
      "(Epoch 2 / 5) train acc: 0.294000; val_acc: 0.230000\n",
      "(Iteration 81 / 200) loss: 1.986923\n",
      "(Iteration 91 / 200) loss: 1.910875\n",
      "(Iteration 101 / 200) loss: 1.915921\n",
      "(Iteration 111 / 200) loss: 1.933449\n",
      "(Epoch 3 / 5) train acc: 0.319000; val_acc: 0.295000\n",
      "(Iteration 121 / 200) loss: 1.994783\n",
      "(Iteration 131 / 200) loss: 2.014771\n",
      "(Iteration 141 / 200) loss: 1.836256\n",
      "(Iteration 151 / 200) loss: 1.941444\n",
      "(Epoch 4 / 5) train acc: 0.345000; val_acc: 0.303000\n",
      "(Iteration 161 / 200) loss: 1.833627\n",
      "(Iteration 171 / 200) loss: 1.809461\n",
      "(Iteration 181 / 200) loss: 1.827637\n",
      "(Iteration 191 / 200) loss: 1.850869\n",
      "(Epoch 5 / 5) train acc: 0.351000; val_acc: 0.308000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.714288\n",
      "(Epoch 0 / 5) train acc: 0.085000; val_acc: 0.073000\n",
      "(Iteration 11 / 200) loss: 2.207565\n",
      "(Iteration 21 / 200) loss: 2.065836\n",
      "(Iteration 31 / 200) loss: 1.989273\n",
      "(Epoch 1 / 5) train acc: 0.344000; val_acc: 0.293000\n",
      "(Iteration 41 / 200) loss: 1.935699\n",
      "(Iteration 51 / 200) loss: 1.907470\n",
      "(Iteration 61 / 200) loss: 1.772728\n",
      "(Iteration 71 / 200) loss: 1.735570\n",
      "(Epoch 2 / 5) train acc: 0.403000; val_acc: 0.321000\n",
      "(Iteration 81 / 200) loss: 1.871194\n",
      "(Iteration 91 / 200) loss: 1.645481\n",
      "(Iteration 101 / 200) loss: 1.752066\n",
      "(Iteration 111 / 200) loss: 1.552741\n",
      "(Epoch 3 / 5) train acc: 0.456000; val_acc: 0.350000\n",
      "(Iteration 121 / 200) loss: 1.667779\n",
      "(Iteration 131 / 200) loss: 1.598745\n",
      "(Iteration 141 / 200) loss: 1.546082\n",
      "(Iteration 151 / 200) loss: 1.390051\n",
      "(Epoch 4 / 5) train acc: 0.477000; val_acc: 0.356000\n",
      "(Iteration 161 / 200) loss: 1.460970\n",
      "(Iteration 171 / 200) loss: 1.458694\n",
      "(Iteration 181 / 200) loss: 1.338012\n",
      "(Iteration 191 / 200) loss: 1.556922\n",
      "(Epoch 5 / 5) train acc: 0.516000; val_acc: 0.354000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:39: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:42: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:49: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  0.032064274004801614\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.394364\n",
      "(Epoch 0 / 5) train acc: 0.116000; val_acc: 0.131000\n",
      "(Iteration 11 / 200) loss: 2.059077\n",
      "(Iteration 21 / 200) loss: 1.734921\n",
      "(Iteration 31 / 200) loss: 1.732321\n",
      "(Epoch 1 / 5) train acc: 0.381000; val_acc: 0.312000\n",
      "(Iteration 41 / 200) loss: 1.722891\n",
      "(Iteration 51 / 200) loss: 1.798904\n",
      "(Iteration 61 / 200) loss: 1.667785\n",
      "(Iteration 71 / 200) loss: 1.640003\n",
      "(Epoch 2 / 5) train acc: 0.408000; val_acc: 0.365000\n",
      "(Iteration 81 / 200) loss: 1.595915\n",
      "(Iteration 91 / 200) loss: 1.374137\n",
      "(Iteration 101 / 200) loss: 1.366740\n",
      "(Iteration 111 / 200) loss: 1.370105\n",
      "(Epoch 3 / 5) train acc: 0.526000; val_acc: 0.369000\n",
      "(Iteration 121 / 200) loss: 1.334581\n",
      "(Iteration 131 / 200) loss: 1.350041\n",
      "(Iteration 141 / 200) loss: 1.320749\n",
      "(Iteration 151 / 200) loss: 1.202973\n",
      "(Epoch 4 / 5) train acc: 0.525000; val_acc: 0.344000\n",
      "(Iteration 161 / 200) loss: 1.218741\n",
      "(Iteration 171 / 200) loss: 1.154502\n",
      "(Iteration 181 / 200) loss: 1.269538\n",
      "(Iteration 191 / 200) loss: 1.318418\n",
      "(Epoch 5 / 5) train acc: 0.586000; val_acc: 0.376000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.576658\n",
      "(Epoch 0 / 5) train acc: 0.115000; val_acc: 0.115000\n",
      "(Iteration 11 / 200) loss: 2.050550\n",
      "(Iteration 21 / 200) loss: 1.959844\n",
      "(Iteration 31 / 200) loss: 1.887341\n",
      "(Epoch 1 / 5) train acc: 0.372000; val_acc: 0.316000\n",
      "(Iteration 41 / 200) loss: 1.725187\n",
      "(Iteration 51 / 200) loss: 1.756796\n",
      "(Iteration 61 / 200) loss: 1.806124\n",
      "(Iteration 71 / 200) loss: 1.680757\n",
      "(Epoch 2 / 5) train acc: 0.415000; val_acc: 0.343000\n",
      "(Iteration 81 / 200) loss: 1.683766\n",
      "(Iteration 91 / 200) loss: 1.492594\n",
      "(Iteration 101 / 200) loss: 1.521136\n",
      "(Iteration 111 / 200) loss: 1.420132\n",
      "(Epoch 3 / 5) train acc: 0.465000; val_acc: 0.365000\n",
      "(Iteration 121 / 200) loss: 1.525172\n",
      "(Iteration 131 / 200) loss: 1.455114\n",
      "(Iteration 141 / 200) loss: 1.563182\n",
      "(Iteration 151 / 200) loss: 1.727025\n",
      "(Epoch 4 / 5) train acc: 0.482000; val_acc: 0.357000\n",
      "(Iteration 161 / 200) loss: 1.446868\n",
      "(Iteration 171 / 200) loss: 1.520950\n",
      "(Iteration 181 / 200) loss: 1.560921\n",
      "(Iteration 191 / 200) loss: 1.286450\n",
      "(Epoch 5 / 5) train acc: 0.540000; val_acc: 0.354000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:40: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 5e-4}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "Becasue the learning rate of AdaGrad is static, it's too aggressive to learn at the end state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 10.359282\n",
      "(Epoch 0 / 10) train acc: 0.140000; val_acc: 0.160000\n",
      "(Epoch 1 / 10) train acc: 0.496000; val_acc: 0.478000\n",
      "(Epoch 2 / 10) train acc: 0.545000; val_acc: 0.507000\n",
      "(Iteration 1001 / 4900) loss: 2.937067\n",
      "(Epoch 3 / 10) train acc: 0.580000; val_acc: 0.513000\n",
      "(Epoch 4 / 10) train acc: 0.595000; val_acc: 0.525000\n",
      "(Iteration 2001 / 4900) loss: 2.028381\n",
      "(Epoch 5 / 10) train acc: 0.645000; val_acc: 0.540000\n",
      "(Epoch 6 / 10) train acc: 0.663000; val_acc: 0.551000\n",
      "(Iteration 3001 / 4900) loss: 1.620959\n",
      "(Epoch 7 / 10) train acc: 0.670000; val_acc: 0.543000\n",
      "(Epoch 8 / 10) train acc: 0.681000; val_acc: 0.552000\n",
      "(Iteration 4001 / 4900) loss: 1.570448\n",
      "(Epoch 9 / 10) train acc: 0.744000; val_acc: 0.557000\n",
      "(Epoch 10 / 10) train acc: 0.737000; val_acc: 0.564000\n",
      "lr: 0.00031, bs: 100 => acc: 0.564\n",
      "Best-Condition: lr: 0.00031, bs: 100 => acc: 0.564\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 18min 23s, sys: 6min 13s, total: 24min 37s\n",
      "Wall time: 16min 54s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "def test(learning_rates = 5e-4,\n",
    "        weight_scale=2.5e-2,\n",
    "        reg = 0.1,\n",
    "        num_epochs=10,\n",
    "        batch_size=100):\n",
    "    model = FullyConnectedNet([600, 400, 100], \n",
    "                              weight_scale=weight_scale, \n",
    "                              reg = reg, \n",
    "                              dtype=np.float64, seed=None)\n",
    "    update_rule = 'adam'\n",
    "    solver = Solver(model, data,\n",
    "                    num_epochs=num_epochs, \n",
    "                    batch_size=batch_size,\n",
    "                    update_rule=update_rule,\n",
    "                    optim_config={\n",
    "                    'learning_rate': learning_rates\n",
    "                    },\n",
    "                    lr_decay=0.9,\n",
    "                    print_every=1000,\n",
    "                    verbose=True)\n",
    "    solvers[update_rule] = solver\n",
    "    solver.train()\n",
    "    acc = solver.val_acc_history[-1]\n",
    "    return acc, solver, model\n",
    "\n",
    "# start test different parameters\n",
    "best_acc = 0\n",
    "best_lr = None\n",
    "best_bs = None\n",
    "best_solver = None\n",
    "for lr in [3.1e-4]:\n",
    "    for bs in [100]:\n",
    "        acc, solver, model = test(learning_rates = lr,\n",
    "                                weight_scale=2.5e-2,\n",
    "                                reg = 1e-2,\n",
    "                                num_epochs=10,\n",
    "                                batch_size=bs)\n",
    "        print(f'lr: {lr}, bs: {bs} => acc: {acc}')\n",
    "        if acc > best_acc:\n",
    "            best_acc = acc\n",
    "            best_lr = lr\n",
    "            best_bs = bs\n",
    "            best_model = model\n",
    "            best_solver = solver\n",
    "            \n",
    "print(f'Best-Condition: lr: {best_lr}, bs: {best_bs} => acc: {best_acc}')\n",
    "\n",
    "# plot the graphs\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(best_solver.loss_history)\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(best_solver.train_acc_history, label='train')\n",
    "plt.plot(best_solver.val_acc_history, label='val')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Clasification accuracy')\n",
    "plt.show() \n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.564\n",
      "Test set accuracy:  0.566\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
